home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et-2_2.lha / et2.2 / src / TextView.C < prev    next >
C/C++ Source or Header  |  1990-12-06  |  19KB  |  816 lines
  1. //$TextView$
  2. #include "TextView.h"
  3.  
  4. #include "TextCmd.h"
  5. #include "CmdNo.h"
  6. #include "String.h"
  7. #include "View.h"
  8. #include "BlankWin.h"
  9. #include "Menu.h"
  10. #include "Error.h"
  11. #include "ChangeDialog.h"
  12. #include "Document.h"
  13. #include "RegularExp.h"
  14. #include "ClipBoard.h"
  15. #include "TextFormatter.h"
  16. #include "ObjectTable.h"
  17.  
  18. static u_short CaretBits[]= {
  19. #   include "images/Caret.image"
  20. };  
  21.  
  22. const int cCaretHt = 4,
  23.       cCaretWd = 7;
  24.  
  25. static Bitmap *CaretImage;
  26.  
  27. void SwapSelPoints(SelPoint &p1, SelPoint &p2)
  28. {
  29.     SelPoint tmp;
  30.  
  31.     tmp= p1; p1= p2; p2= tmp;
  32. }
  33.  
  34. //----- TextView Methods --------------------------------------------------
  35.  
  36. MetaImpl(TextView, (TB(updateSelection), TB(inTextSelector), 
  37.     TP(stopChars), TP(Typeing), TP(findChange), 
  38.     TP(scratchText), T(start.ch), T(start.line), T(start.viewp),
  39.     T(end.ch), T(end.line), T(end.viewp), 0));
  40.  
  41. TextView::TextView(EvtHandler *eh, Rectangle r, Text *t, eTextJust m, eSpacing sp, 
  42.                bool doWrap, TextViewFlags fl, Point b, int id)
  43.                 : StaticTextView(eh, r, t, m, sp, doWrap, fl, b, id) 
  44. {
  45.     Init();
  46. }
  47.  
  48. void TextView::InitNew()
  49. {
  50.     View::InitNew();
  51.     inTextSelector= FALSE;
  52. }  
  53.  
  54. void TextView::Init()
  55. {
  56.     PrivSetSelection(0, 0, FALSE);
  57.     Typeing= 0;
  58.     stopChars= 0;
  59.     updateSelection= TRUE;
  60.     text->AddObserver(this);
  61.     scratchText= text->GetScratchText(cMaxBatchedIns);
  62.     findChange= 0;
  63. }
  64.  
  65. TextView::~TextView()
  66. {
  67.     if (text)
  68.     text->RemoveObserver(this);
  69.     SafeDelete(stopChars);
  70.     if (findChange)
  71.     findChange->Close();
  72.     SafeDelete(findChange);
  73.     SafeDelete(scratchText);
  74. }
  75.  
  76. void TextView::InvalidateSelection()
  77. {
  78.     if (AnySelection())
  79.     InvalidateRange(start.line, start.viewp, end.line, end.viewp);
  80. }
  81.  
  82. void TextView::Draw(Rectangle r)
  83. {
  84.     if (GrHasColor() && AnySelection())
  85.     Invert(start.line, start.viewp, end.line, end.viewp);
  86.     StaticTextView::Draw(r);
  87.     DrawCaret(start.viewp, start.line, On);
  88.     if (!GrHasColor() && AnySelection())
  89.     Invert(start.line, start.viewp, end.line, end.viewp);
  90. }
  91.  
  92. static Ink *caretColor;
  93.     
  94. void TextView::DrawCaret(Point p, int line, HighlightState)
  95. {
  96.     if (! inTextSelector && AnySelection() && Caret()) {
  97.     int bh= BaseHeight(line);
  98.     p+= GetInnerOrigin();
  99.  
  100.     if (caretColor == 0) {
  101.         if (GrHasColor())
  102.         caretColor= new RGBColor(255, 0, 0);
  103.         else
  104.         caretColor= ePatXor;
  105.     }
  106.     
  107.     if (LineHeight(line) - bh >= cCaretHt) {
  108.         Rectangle r(p.x-cCaretHt, p.y+bh, cCaretWd, cCaretHt);
  109.         if (CaretImage == 0)
  110.         ObjectTable::AddRoot(
  111.             CaretImage= new Bitmap(Point(cCaretWd, cCaretHt), CaretBits));
  112.         GrPaintBitMap(r, CaretImage, caretColor);
  113.     }
  114.     p.x--;
  115.     GrPaintLine(caretColor, 1, eDefaultCap, Point(p.x, p.y), Point(p.x, p.y+bh));
  116.     }
  117. }
  118.  
  119. //---- highlight the characters in the given range -----------------------
  120.  
  121. void TextView::Invert(int from, Point fp, int to, Point tp)
  122. {
  123.     if (AnySelection() && !Caret()) {
  124.     Rectangle r;
  125.     
  126.     if ((from == to && fp.x > tp.x) || from > to) { // normalize range
  127.         swap(from, to);
  128.         Swap(fp, tp);   
  129.     }
  130.     
  131.     if (from == to) {
  132.         r= Rectangle(LineToPoint(from)+Point (fp.x,0),
  133.                Point(tp.x-fp.x, LineHeight(from)));
  134.         GrPaintRect(r+GetInnerOrigin(), gHighlightColor);
  135.         return;
  136.     }
  137.     r= Rectangle(LineToPoint(from)+ Point(fp.x,0),
  138.               Point(GetInnerExtent().x-fp.x, LineHeight(from)));
  139.     GrPaintRect(r+GetInnerOrigin(), gHighlightColor);
  140.     r= Rectangle(LineToPoint(from + 1), Point(GetInnerExtent().x,
  141.               LineToPoint(to).y - LineToPoint(from + 1).y));
  142.     GrPaintRect(r+GetInnerOrigin(), gHighlightColor);
  143.     r= Rectangle(LineToPoint(to), Point(tp.x, LineHeight(to)));
  144.     GrPaintRect(r+GetInnerOrigin(), gHighlightColor);
  145.     }
  146. }
  147.  
  148. void TextView::Reformat()
  149. {
  150.     StaticTextView::Reformat();
  151.     if (AnySelection())
  152.     SetSelection(start.ch, end.ch, FALSE);
  153. }
  154.  
  155. void TextView::SetNoSelection(bool redraw)
  156. {
  157.     if (AnySelection()) {
  158.     InvalidateSelection();
  159.     start.ch= end.ch= -1;
  160.     if (redraw)
  161.         UpdateEvent();
  162.     }
  163. }
  164.  
  165. void TextView::PrivSetSelection(SelPoint s, SelPoint e, bool redraw)
  166. {
  167.     InvalidateSelection();          // invalidate old selection
  168.     start= s;
  169.     end= e;
  170.     InvalidateSelection();          // invalidate new selection
  171.     if (redraw)
  172.     UpdateEvent();
  173. }
  174.  
  175. void TextView::PrivSetSelection(int s, int e, bool redraw)
  176. {
  177.     SelPoint sp, ep;
  178.     int size= text->Size();
  179.     
  180.     sp.ch= range(0, size, s);
  181.     ep.ch= range(0, size, e);
  182.     CharToPos(sp.ch, &sp.line, &sp.viewp);
  183.     if (sp.ch != ep.ch)
  184.     CharToPos(ep.ch, &ep.line, &ep.viewp);
  185.     else
  186.     ep= sp;
  187.     PrivSetSelection(sp, ep, redraw);
  188. }
  189.  
  190. void TextView::SetSelection(int s, int e, bool redraw)
  191. {
  192.     DoneTypeing();
  193.     PrivSetSelection(s, e, redraw);
  194. }
  195.  
  196. void TextView::SelectionAsString(byte *buf, int max)
  197. {
  198.     GetText()->CopyInStr(buf, max, start.ch, end.ch);
  199. }
  200.  
  201. Text *TextView::SelectionAsText()
  202. {
  203.     return text->Save(start.ch, end.ch);
  204. }
  205.  
  206. void TextView::RevealSelection()
  207. {
  208.     if (AnySelection()) {
  209.     Rectangle r= SelectionRect().Expand(8);
  210.     RevealRect(r, r.extent);
  211.     }
  212. }
  213.      
  214. Rectangle TextView::SelectionRect()
  215. {
  216.     if (AnySelection()) {
  217.     Point p(end.viewp.x+1, end.viewp.y + LineHeight(end.line));
  218.     Rectangle r= NormRect(start.viewp, p);
  219.     r.origin+= GetInnerOrigin();
  220.     return r;
  221.     }
  222.     return gRect0;
  223. }
  224.  
  225. Command *TextView::DoLeftButtonDownCommand(Point lp, Token t, int clicks)
  226. {
  227.     SelPoint oldStart, oldEnd;
  228.     TextRangeFP rf= CharacterRange;
  229.     
  230.     oldStart= start;
  231.     oldEnd= end;
  232.     formatter->ResumeFormat();
  233.     if (! Enabled())
  234.     return View::DoLeftButtonDownCommand(lp, t, clicks);
  235.     
  236.     Control(GetId(), cPartWantKbdFocus, this);
  237.     
  238.     if (clicks >= 3)
  239.     rf= ParagraphRange;
  240.     else if (clicks >= 2) 
  241.     rf= WordRange;
  242.  
  243.     if (t.Flags == eFlgShiftKey) 
  244.     return new ExtendRangeSelector(this, rf);  
  245.     
  246.     if (t.Flags == eFlgCntlKey && clicks == 1) 
  247.     return new CopyDragPasteSelector(this, oldStart.ch, oldEnd.ch); 
  248.  
  249.     if (t.Flags == (eFlgShiftKey|eFlgCntlKey) && clicks == 1)
  250.     return new QuickPasteSelector(this, oldStart.ch, oldEnd.ch);
  251.     
  252.     if (t.Flags == 0)
  253.     return new RangeSelector(this, rf);
  254.     return View::DoLeftButtonDownCommand(lp, t, clicks);
  255. }
  256.  
  257. void TextView::SetStopChars(char *stops)
  258. {
  259.     strreplace(&stopChars, stops);
  260. }
  261.  
  262. Command *TextView::DoKeyCommand(int ch, Point, Token token)
  263. {
  264.     int nDelete= 0;
  265.     Token t;
  266.     bool newCmd, delSelection;       // delete the selection only
  267.  
  268.     if (!Writeable())
  269.     return gNoChanges;
  270.     if (token.Code == 'd' + 128 && gDebug) {
  271.     Dump();
  272.     return gNoChanges;
  273.     }
  274.  
  275.     GrSetCursor(eCrsNone);
  276.     //---- map \r to to \n ???
  277.     if (ch == '\r')
  278.     ch= '\n';
  279.  
  280.     newCmd= (Typeing == 0 || Typeing->completed); // start new typing sequence?
  281.  
  282.     if (newCmd) {
  283.     if (Typeing)
  284.         Typeing->SetFlag(eCmdDoDelete);
  285.     Typeing= new TypeingCommand(this, cTYPEING, "typing");
  286.     }
  287.  
  288.     delSelection= (newCmd && !Caret());
  289.     if (ch != gBackspace || delSelection) {     
  290.     for (;;) {
  291.         if (ch != gBackspace) {
  292.         Typeing->AddChar();
  293.         scratchText->Append(ch);
  294.         }
  295.         if (scratchText->Size() == cMaxBatchedIns)
  296.         break;
  297.         t= gWindow->ReadEvent(0);
  298.         if (t.IsAscii() && (byte)t.Code != gBackspace 
  299.             // do not batch stopChars
  300.             && !(stopChars && index(stopChars, (byte)t.Code)) 
  301.             && ! TestFlag(eTextViewNoBatch)) {
  302.         ch= (byte) t.Code;
  303.         } else {
  304.         gWindow->PushBackEvent(t);
  305.         break;
  306.         } 
  307.     }
  308.     Paste(scratchText);
  309.     scratchText->Empty();
  310.     } else {
  311.     for (;;) {
  312.         Typeing->DelChar();
  313.         nDelete++;
  314.         t= gWindow->ReadEvent(0);
  315.         if ((byte) t.Code != gBackspace) {
  316.         gWindow->PushBackEvent(t);
  317.         break;
  318.         } 
  319.     } 
  320.     DelChar(nDelete);
  321.     }
  322.     RevealSelection();
  323.     return Typeing;    
  324. }
  325.  
  326. Command *TextView::DoCursorKeyCommand(EvtCursorDir cd, Point p, Token)
  327. {
  328.     int charNo= 0;
  329.  
  330.     if (!Enabled())
  331.     return gNoChanges;
  332.     switch (cd) {
  333.     case eCrsLeft:
  334.     charNo= start.ch-1;
  335.     break;
  336.     case eCrsRight:
  337.     charNo= end.ch+1;
  338.     break;
  339.     case eCrsUp:
  340.     formatter->ResumeFormat();
  341.     charNo= CursorPos(start.ch, start.line, cd, p);
  342.     break;
  343.     case eCrsDown:
  344.     formatter->ResumeFormat();
  345.     charNo= CursorPos(end.ch, end.line, cd, p);
  346.     break;
  347.     }
  348.     SetSelection(charNo, charNo);
  349.     RevealSelection();
  350.     return gNoChanges;
  351. }
  352.  
  353. int TextView::CursorPos(int at, int line, EvtCursorDir d, Point p)
  354. {
  355.     int charNo;
  356.     Point basePoint,screenPoint;
  357.  
  358.     CharToPos (at, &line, &screenPoint);
  359.     if (d == eCrsDown)
  360.     line= min(nLines-1, line+1);
  361.     else
  362.     line= max(0, line-1);        
  363.     basePoint= LineToPoint(line, TRUE) + Point(screenPoint.x, 0);
  364.     PointToPos(basePoint, &p, &line, &charNo);
  365.     return charNo;
  366. }
  367.  
  368. Command *TextView::DoOtherEventCommand(Point, Token t)
  369. {
  370.     if (t.Code == eEvtLocMove && TestFlag(eTextFormPreempt))
  371.     formatter->ResumeFormat();
  372.     return gNoChanges;
  373. }
  374.  
  375. GrCursor TextView::GetCursor(Point)
  376. {
  377.     return eCrsIBeam;
  378. }
  379.  
  380. Command *TextView::DoIdleCommand()
  381. {
  382.     if (TestFlag(eTextFormPreempt))
  383.     formatter->ResumeFormat(TRUE);
  384.     return View::DoIdleCommand();
  385. }
  386.  
  387. void TextView::DoneTypeing()
  388. {
  389.     if (Typeing)
  390.     Typeing->completed= TRUE;
  391.     text->ResetCurrentStyle();
  392.     formatter->ResumeFormat();
  393. }
  394.  
  395. void TextView::TypeingDeleted()
  396. {
  397.     Typeing= 0;  
  398. }
  399.  
  400. bool TextView::DeleteRequest(int,int)
  401. {
  402.     return TRUE;
  403. }
  404.  
  405. void TextView::Cut()
  406. {
  407.     if (!Writeable())
  408.     return; 
  409.     if (DeleteRequest(start.ch, end.ch) && AnySelection()) {
  410.     updateSelection= FALSE;
  411.     text->Cut(start.ch, end.ch);
  412.     updateSelection= TRUE;
  413.     PrivSetSelection(start.ch, start.ch, FALSE);
  414.     }
  415. }
  416.  
  417. void TextView::Copy(Text *t)
  418. {
  419.     text->Copy(t, start.ch, end.ch);
  420. }
  421.  
  422. void TextView::Paste(Text *t)
  423. { 
  424.     if (!Writeable())
  425.     return;
  426.     if ((!Caret() && !DeleteRequest(start.ch, end.ch)) || !AnySelection())
  427.     return;
  428.     // minor hack: if text is appended on the last line, 
  429.     // fake last line to reach a mark 
  430.     if (wrap && start.line == nLines-1) 
  431.     MarkAtLine(start.line)->len= cMaxInt;
  432.     updateSelection= FALSE;
  433.     text->Paste(t, start.ch, end.ch);
  434.     updateSelection= TRUE;
  435.     PrivSetSelection(start.ch+t->Size(), start.ch+t->Size(), FALSE);       
  436. }
  437.  
  438. Command *TextView::InsertText(Text *t)
  439. {
  440.     if (!Writeable())
  441.     return gNoChanges;
  442.  
  443.     bool newCmd;
  444.     newCmd= (Typeing == 0 || Typeing->completed); // start new typing sequence?
  445.  
  446.     if (newCmd) {
  447.     if (Typeing)
  448.         Typeing->SetFlag(eCmdDoDelete);
  449.     Typeing= new TypeingCommand(this, cTYPEING, "typing");
  450.     }
  451.  
  452.     Typeing->AddChar(t->Size());
  453.     Paste(t);
  454.     return Typeing;
  455. }
  456.  
  457. void TextView::DelChar (int n)
  458. {
  459.     int newStart= max(0, start.ch-n);
  460.     int changedLine= CharToLine(newStart);
  461.  
  462.     if (newStart == start.ch)
  463.     return;
  464.     if (newStart == 0 && start.ch == 0)
  465.     return;
  466.     if (DeleteRequest(newStart, start.ch)) {
  467.     updateSelection= FALSE;   
  468.     text->Cut(newStart, start.ch);
  469.     updateSelection= TRUE;
  470.     PrivSetSelection(newStart, newStart, FALSE);       
  471.     }
  472. }
  473.  
  474. Text *TextView::SetText(Text *t)
  475. {
  476.     Text *old= text;
  477.     old->RemoveObserver(this);
  478.     bool anySel= AnySelection();
  479.     PrivSetSelection(0, 0, FALSE); // reset old selection
  480.     text= t;    // should remove possible reference from a command object ???
  481.     SafeDelete(nextc);
  482.     nextc= text->MakeIterator();
  483.     SafeDelete(scratchText);
  484.     scratchText= text->GetScratchText(cMaxBatchedIns);
  485.     text->AddObserver(this);
  486.     Reformat();  
  487.     Send(GetId(), cPartReplacedText, 0);
  488.     SetSelection(0, 0, FALSE); // set new selection
  489.     if (!anySel)
  490.     SetNoSelection(FALSE);  
  491.     Typeing= 0;
  492.     return old;
  493. }       
  494.  
  495. void TextView::SetString(byte *str, int len)
  496. {
  497.     bool anySel= AnySelection();
  498.     PrivSetSelection(0, 0, FALSE); 
  499.     text->ReplaceWithStr(str, len);
  500.     Reformat();
  501.     Send(GetId(), cPartReplacedText, 0);
  502.     DoneTypeing();
  503.     PrivSetSelection(0, 0, FALSE); 
  504.     if (!anySel)
  505.     SetNoSelection(FALSE);  
  506.     Typeing= 0;
  507. }
  508.  
  509. void TextView::SetReadOnly(bool m)
  510. {
  511.     SetFlag(eTextViewReadOnly, m);
  512. }
  513.  
  514. bool TextView::GetReadOnly()
  515. { 
  516.     return TestFlag(eTextViewReadOnly); 
  517. }
  518.  
  519. void TextView::DoObserve(int, int part, void *what, Object *op)
  520. {
  521.     int d= 0, d1= 0;
  522.     
  523.     if (op == text && part != cPartSenderDied) {
  524.     TextChanges *tc= (TextChanges*)what;
  525.     int fl= CharToLine(tc->from), tl; // lines corresponding from, to
  526.     if (tc->from == tc->to)
  527.         tl= fl;
  528.     else 
  529.         tl= CharToLine(tc->to);
  530.  
  531.     switch (part) {
  532.     case eTextChangedRange:
  533.         ChangedAt(fl, tc->from, TRUE, tl);
  534.         if (updateSelection && AnySelection())
  535.         PrivSetSelection(tc->from, tc->to, TRUE);
  536.         break;
  537.  
  538.     case eTextDeleted:
  539.         marks->Cut(tc->from, tc->to - tc->from);
  540.         d = DeleteLines (fl, tl);
  541.         ChangedAt(fl, tc->from, d > 0);
  542.         if (updateSelection && AnySelection())
  543.         PrivSetSelection(tc->from, tc->from, TRUE);
  544.         break;
  545.  
  546.     case eTextReplaced:
  547.         if (tc->from != tc->to) {
  548.         marks->Cut(tc->from, tc->to - tc->from);
  549.         d1= DeleteLines(fl, tl);
  550.         }
  551.         marks->Paste(tc->from, tc->size); 
  552.         d= FormatInsertedText(fl, tc->from, tc->size);
  553.         ChangedAt(fl+d, tc->from, d > 0 || d1 > 0);
  554.         if (updateSelection && AnySelection()) {
  555.         int p= tc->from+tc->size;
  556.         PrivSetSelection(p, p, TRUE);   
  557.         }    
  558.         break;
  559.     }
  560.     if (TestFlag(eVObjLayoutCntl)) 
  561.         Control(GetId(), cPartChangedText, this);
  562.     Send(GetId(), cPartChangedText, this);    // notify observers of the textview   
  563.     }
  564. }
  565.  
  566. bool TextView::PrintOnWhenObserved(Object *from)
  567. {
  568.     return GetText() != from;
  569. }
  570.  
  571. istream& TextView::ReadFrom(istream &s)
  572. {
  573.     StaticTextView::ReadFrom(s);
  574.     GetText()->AddObserver(this);
  575.     scratchText= text->GetScratchText(cMaxBatchedIns);
  576.     return s;
  577. }
  578.  
  579. void TextView::NormSelection()
  580. {
  581.     if (start.ch > end.ch) 
  582.     SwapSelPoints(start, end);
  583. }
  584.  
  585. //---- erichsneusterhack
  586.  
  587. static ObjArray *saved;
  588. MarkList *savedMarks;
  589. static bool doSwap= FALSE;
  590. static int swapAt;
  591.  
  592. void TextView::StartFormatting()
  593. {
  594.     if (doSwap) {
  595.     // temporary replacement of the array with the line marks
  596.     saved= lines;
  597.     savedMarks= marks;
  598.     marks= new MarkList;
  599.     lines= new ObjArray(12, swapAt);
  600.     }
  601. }
  602.  
  603. int TextView::FormatInsertedText(int at, int startCh, int n)
  604. {
  605.     if (!formatter->IsKindOf(SimpleFormatter)) // ugly optimization for Simpleformatter
  606.     return 0;
  607.  
  608.     int end, upto, d;
  609.     LineMark *m;
  610.     
  611.     formatter->Preemptive(FALSE);
  612.     doSwap= TRUE;
  613.     swapAt= at;
  614.     upto= startCh + n;
  615.     end= formatter->DoIt(at, upto);
  616.     d= max(0, end - at);
  617.     swap((Object**)&saved, (Object**)&lines);
  618.     swap((Object**)&savedMarks, (Object**)&marks);
  619.     if (d > 0) {
  620.     for (int i= nLines-1; i > at; i--) { // make room for new lines
  621.         m= MarkAtLine(i);
  622.         MarkLine(i+d, m->pos, m->pos+m->len, &m->ld);
  623.     } 
  624.     for (i= at; i <= at + d; i++) {  // insert the new formatted lines
  625.         m= (LineMark*)(*saved)[i];
  626.         MarkLine(i, m->pos, m->pos+m->len, &m->ld);
  627.     }
  628.     MarkLineAsChanged(i-1);           // mark the last line as changed
  629.     }
  630.     nLines+= d; 
  631.     savedMarks->FreeAll();
  632.     delete savedMarks;
  633.     delete saved; 
  634.     InvalidateRange(at, at+d);
  635.     formatter->Preemptive(TRUE);
  636.     doSwap= FALSE;
  637.     return d;
  638. }
  639.  
  640. int TextView::DeleteLines(int from, int to)
  641. {
  642.     int d= to - from;
  643.     if (d > 0) {
  644.     for (int i= from + 1; i < nLines-d; i++) {
  645.         LineMark *m= MarkAtLine(i+d);
  646.         MarkLine(i, m->pos, m->pos+m->len, &m->ld);
  647.     } 
  648.     nLines-= d;
  649.     MarkLineAsChanged(from);
  650.     }
  651.     return d;
  652. }
  653.  
  654. void TextView::Dump()
  655. {
  656.     StaticTextView::Dump();
  657.     cerr << "Selection: start = " << start.ch << "," << start.line;
  658.     cerr << " end = " << end.ch << "," << end.line NL;
  659.     for (int i= start.ch; i < end.ch; i++)
  660.     cerr.put((*text)[i]);
  661.     cerr NL;
  662. }
  663.  
  664. //---- menu related commands -----------------------------------------------
  665.  
  666. void TextView::DoCreateMenu(Menu *mp)
  667. {
  668.     View::DoCreateMenu(mp);
  669.     if (!TestFlag(eTextNoFind)) {
  670.     char *fs= GetReadOnly() ? "find..." : "find/change...";
  671.     mp->InsertItemsAfter(cLASTEDIT, "select all",   cSELECTALL,
  672.                     fs,             cFIND,
  673.                     0);
  674.     }
  675. }
  676.  
  677. bool TextView::HasSelection()
  678. {
  679.     return AnySelection() && !Caret();
  680. }
  681.  
  682. void TextView::SelectionToClipboard(char *type, ostream &os)
  683. {
  684.     Text *t= SelectionAsText();
  685.     if (t) {
  686.     if (strcmp(type, cDocTypeET) == 0)
  687.         os << t SP;
  688.     else if (strcmp(type, cDocTypeAscii) == 0)
  689.         t->PrintOnAsPureText(os);
  690.     delete t;
  691.     }
  692. }
  693.  
  694. Command *TextView::PasteData(char *type, istream &s)
  695. {
  696.     if (strcmp(type, cDocTypeET) == 0) {
  697.     Object *op= 0;
  698.     s >> op;
  699.     if (op && op->IsKindOf(Text))
  700.         return new PasteCommand(this, (Text*)op);
  701.     } else if (strcmp(type, cDocTypeAscii) == 0)
  702.     return new PasteCommand(this, new GapText((byte*)s.bufptr()));
  703.     return gNoChanges;
  704. }
  705.  
  706. bool TextView::CanPaste(char *type)
  707. {
  708.     return strismember(type, cDocTypeET, cDocTypeAscii, 0);
  709. }
  710.  
  711. void TextView::DoSetupMenu(Menu *mp)
  712. {
  713.     View::DoSetupMenu(mp);
  714.     if (!GetReadOnly()) {
  715.     if (!Caret())
  716.         mp->EnableItem(cCUT);
  717.     if (AnySelection())
  718.         mp->EnableItem(cPASTE);
  719.     }
  720.     if (AnySelection())
  721.     mp->EnableItems(cSELECTALL, cFIND, 0);
  722. }
  723.  
  724. Command *TextView::DoMenuCommand(int cmd)
  725. {
  726.     switch (cmd) {
  727.     case cCUT:
  728.     gClipBoard->SetType((char*) cDocTypeET);
  729.     View::DoMenuCommand(cmd);
  730.     return new CutCopyCommand(this, cCUT);
  731.     case cCOPY:
  732.     gClipBoard->SetType((char*) cDocTypeET);
  733.     View::DoMenuCommand(cmd);
  734.     return new CutCopyCommand(this, cCOPY);
  735.     case cSELECTALL:
  736.     SelectAll();
  737.     break;
  738.     case cFIND:
  739.     if (findChange == 0) {
  740.         findChange= MakeFindDialog();
  741.         Document *dp= GetDocument();
  742.         if (dp)
  743.         GetDocument()->AddWindow(findChange->GetWindow());
  744.     }
  745.     findChange->ShowOnWindow(GetWindow());
  746.     return gNoChanges;
  747.     default:
  748.     return View::DoMenuCommand(cmd);
  749.     }
  750.     return gNoChanges;
  751. }
  752.  
  753. void TextView::SendDown(int id, int part, void *val)
  754. {
  755.     switch (part) {
  756.     case cPartFocusChanged:
  757.     bool dontRedraw= ((bool) val);
  758.     if (id == cIdStartKbdFocus)   
  759.         SetSelection(0, cMaxInt, !dontRedraw);
  760.     else 
  761.         SetNoSelection(!dontRedraw);
  762.     break;
  763.     case cPartHasSelection:  
  764.     *(bool*)val= HasSelection();
  765.     break;
  766.     default:
  767.     StaticTextView::SendDown(id, part, val);
  768.     }
  769. }
  770.  
  771. FindDialog *TextView::MakeFindDialog()
  772. {
  773.     if (GetReadOnly())
  774.     return new FindDialog("Find", this);
  775.     return new ChangeDialog("Find/Change", this);
  776. }
  777.  
  778. bool TextView::SelectRegExpr(RegularExp *rex, bool forward)
  779. {
  780.     int selStart, selEnd, pos, matched;
  781.  
  782.     GetSelection(&selStart, &selEnd);
  783.     if (forward)
  784.     pos= GetText()->Search(rex, &matched, selEnd);
  785.     else
  786.     pos= GetText()->Search(rex, &matched, max(0,selStart-1), cMaxInt, FALSE);
  787.  
  788.     if (pos != -1) {
  789.     SetSelection(pos, pos+matched);
  790.     return TRUE;
  791.     }
  792.     return FALSE;
  793. }
  794.  
  795. void TextView::Home()
  796. {
  797.     SetSelection(0, 0);
  798. }
  799.  
  800. void TextView::Bottom()
  801. {
  802.     SetSelection(cMaxInt, cMaxInt);
  803. }
  804.  
  805. void TextView::SelectAll()
  806. {
  807.     SetSelection(0, text->Size());
  808. }
  809.  
  810. void TextView::Enable(bool b, bool redraw)
  811. {
  812.     StaticTextView::Enable(b, redraw);
  813.     if (! Enabled())
  814.     SetNoSelection(TRUE);
  815. } 
  816.